home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / netbon.zip / NETBINDW.INC < prev    next >
Text File  |  1991-11-25  |  28KB  |  1,082 lines
  1. {
  2.  NETBINDW.INC 1.1
  3. }
  4.  
  5. function AddObjectToSet(ObjType : Word; ObjName : ObjNameStr;
  6.                         PropertyName : PropertyStr;
  7.                         MemberObjType : Word;
  8.                         MemberObjName : ObjNameStr) : Byte;
  9.  
  10. type
  11.   TRequest      = record
  12.                     Len     : Word;
  13.                     SubF    : Byte;
  14.                     ObjT    : Word;
  15.                     Buf     : Array[1..118] of Byte;
  16.                   end;
  17.  
  18. var
  19.   Request       : ^TRequest;
  20.   Reply         : ^Word;
  21.   NovRegs       : Registers;
  22.   Incr          : Word;
  23.   Index         : Byte;
  24.   S, P : Pointer;
  25. begin
  26.   AddObjectToSet := DPMIErrorVal;
  27.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  28.   Request := P;
  29.   Reply := P;
  30.   Inc(Word(Reply), SizeOf(TRequest));
  31.   Reply^ := $0000;
  32.  
  33.   with Request^ do begin
  34.     SubF   := SubFAddObjToSet;
  35.     ObjT   := Swap(ObjType);
  36.     Index  := 1;
  37.     Incr   := Succ(Length(ObjName));
  38.     Move(ObjName,Buf[Index],Incr);
  39.     Inc(Index,Incr);
  40.  
  41.     Incr   := Succ(Length(PropertyName));
  42.     Move(PropertyName,Buf[Index],Incr);
  43.     Inc(Index,Incr);
  44.     MemberObjType := Swap(MemberObjType);
  45.     Move(MemberObjType,Buf[Index],SizeOf(Word));
  46.     Inc(Index,SizeOf(Word));
  47.     Incr   := Succ(Length(MemberObjName));
  48.     Move(MemberObjName,Buf[Index],Incr);
  49.     Inc(Index,Incr);
  50.     Len := Index + 2; {3?}
  51.   end;
  52.  
  53.   with NovRegs do begin
  54.     AH := BinderyFunc;
  55.     DS := SegOfs(S).Segm;
  56.     SI := 0;
  57.     ES := SegOfs(S).Segm;
  58.     DI := SizeOf(TRequest);
  59.     WinIntr($21, NovRegs);
  60.     AddObjectToSet := AL;
  61.   end;
  62.   FreeRealModeMem(P);
  63. end;
  64.  
  65. function ChangePassword(ObjType : Word; ObjName : ObjNameStr;
  66.                         OldPassword, NewPassword : PasswordStr) : Byte;
  67.  
  68. const
  69.   BufSize = (SizeOf(PasswordStr) * 2) + SizeOf(ObjNameStr);
  70. type
  71.   TRequest = record
  72.                Len     : Word;
  73.                SubF    : Byte;
  74.                ObjT    : Word;
  75.                Buf     : Array[1..BufSize] of Byte;
  76.              end;
  77. var
  78.   Request : ^TRequest;
  79.   Reply   : ^Word;
  80.   NovRegs : Registers;
  81.   Incr    : Word;
  82.   Index   : Word;
  83.   S, P : Pointer;
  84. begin
  85.   ChangePassword := DPMIErrorVal;
  86.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  87.   Request := P;
  88.   Reply := P;
  89.   Inc(Word(Reply), SizeOf(TRequest));
  90.   Reply^ := $0000;
  91.  
  92.   with Request^ do begin
  93.     SubF   := SubFChangeObjPass;
  94.     ObjT   := Swap(ObjType);
  95.     Index  := 1;
  96.     Incr   := Succ(Length(ObjName));
  97.     Move(ObjName,Buf[Index],Incr);
  98.     Inc(Index,Incr);
  99.  
  100.     Incr   := Succ(Length(OldPassword));
  101.     Move(OldPassword,Buf[Index],Incr);
  102.     Inc(Index,Incr);
  103.     Incr   := Succ(Length(NewPassword));
  104.     Move(NewPassword,Buf[Index],Incr);
  105.     Inc(Index,Incr);
  106.     Len := Index + 2; {3?}
  107.   end;
  108.  
  109.   with NovRegs do begin
  110.     AH := BinderyFunc;
  111.     DS := SegOfs(S).Segm;
  112.     SI := 0;
  113.     ES := SegOfs(S).Segm;
  114.     DI := SizeOf(TRequest);
  115.     WinIntr($21, NovRegs);
  116.     ChangePassword := AL;
  117.   end;
  118.   FreeRealModeMem(P);
  119. end;
  120.  
  121. function ChangeObjectSecurity(ObjType : Word; ObjName : ObjNameStr;
  122.                               NewSecurity : Byte) : Byte;
  123.  
  124. type
  125.   TRequest = record
  126.               Len     : Word;
  127.               SubF    : Byte;
  128.               NewSec  : Byte;
  129.               ObjT    : Word;
  130.               ObjN    : ObjNameStr;
  131.             end;
  132. var
  133.   Request : ^TRequest;
  134.   Reply   : ^Word;
  135.   NovRegs : Registers;
  136.   S, P : Pointer;
  137.  
  138. begin
  139.   ChangeObjectSecurity := DPMIErrorVal;
  140.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  141.   Request := P;
  142.   Reply := P;
  143.   Inc(Word(Reply), SizeOf(TRequest));
  144.   Reply^ := $0000;
  145.  
  146.   with Request^ do begin
  147.     Len     := Length(ObjName) + 4;
  148.     SubF    := SubFChangeObjSec;
  149.     NewSec  := NewSecurity;
  150.     ObjT    := Swap(ObjType);
  151.     ObjN    := ObjName;
  152.   end;
  153.  
  154.   with NovRegs do begin
  155.     AH := BinderyFunc;
  156.     DS := SegOfs(S).Segm;
  157.     SI := 0;
  158.     ES := SegOfs(S).Segm;
  159.     DI := SizeOf(TRequest);
  160.     WinIntr($21, NovRegs);
  161.     ChangeObjectSecurity := AL;
  162.   end;
  163.   FreeRealModeMem(P);
  164. end;
  165.  
  166. function ChangePropertySecurity(ObjType : Word; ObjName : ObjNameStr;
  167.                                 PropertyName : PropertyStr;
  168.                                 NewPropertySecurity : Byte) : Byte;
  169.  
  170.  
  171. const
  172.   BufSize = SizeOf(ObjNameStr) + SizeOf(PropertyStr) + SizeOf(Byte);
  173. type
  174.   TRequest = record
  175.               Len     : Word;
  176.               SubF    : Byte;
  177.               ObjT    : Word;
  178.               Buf     : Array[1..BufSize] of Byte;
  179.             end;
  180. var
  181.   Request : ^TRequest;
  182.   Reply   : ^Word;
  183.   NovRegs : Registers;
  184.   Incr    : Word;
  185.   Index   : Word;
  186.   S, P : Pointer;
  187. begin
  188.   ChangePropertySecurity := DPMIErrorVal;
  189.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  190.   Request := P;
  191.   Reply := P;
  192.   Inc(Word(Reply), SizeOf(TRequest));
  193.   Reply^ := $0000;
  194.  
  195.   with Request^ do begin
  196.     SubF   := SubFChangePropSec;
  197.     ObjT   := Swap(ObjType);
  198.     Index  := 1;
  199.     Incr   := Succ(Length(ObjName));
  200.     Move(ObjName,Buf[Index],Incr);
  201.     Inc(Index,Incr);
  202.     Buf[Index] := NewPropertySecurity;
  203.     Inc(Index);
  204.  
  205.     Incr   := Succ(Length(PropertyName));
  206.     Move(PropertyName,Buf[Index],Incr);
  207.     Inc(Index,Incr);
  208.     Len := Index + 2; {3?}
  209.   end;
  210.  
  211.   with NovRegs do begin
  212.     AH := BinderyFunc;
  213.     DS := SegOfs(S).Segm;
  214.     SI := 0;
  215.     ES := SegOfs(S).Segm;
  216.     DI := SizeOf(TRequest);
  217.     WinIntr($21, NovRegs);
  218.     ChangePropertySecurity := AL;
  219.   end;
  220.   FreeRealModeMem(P);
  221. end;
  222.  
  223. function CloseBindery : Boolean;
  224.  
  225. type
  226.   TRequest = record
  227.                Len  : Word;
  228.                SubF : Byte;
  229.              end;
  230. var
  231.   Request : ^TRequest;
  232.   Reply   : ^Word;
  233.   NovRegs : Registers;
  234.   S, P : Pointer;
  235. begin
  236.   CloseBindery := False;
  237.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  238.   Request := P;
  239.   Reply := P;
  240.   Inc(Word(Reply), SizeOf(TRequest));
  241.   Reply^ := $0000;
  242.  
  243.   with Request^ do begin
  244.     Len  := 1;
  245.     SubF := SubFCloseBindery;
  246.   end;
  247.  
  248.   with NovRegs do begin
  249.     AH := BinderyFunc;
  250.     DS := SegOfs(S).Segm;
  251.     SI := 0;
  252.     ES := SegOfs(S).Segm;
  253.     DI := SizeOf(TRequest);
  254.     WinIntr($21, NovRegs);
  255.     CloseBindery := AL = 0;
  256.   end;
  257.   FreeRealModeMem(P);
  258. end;
  259.  
  260. function CreateObject(ObjType : Word; ObjName : ObjNameStr;
  261.                       DynamicObj : Boolean;
  262.                       ObjSecurity : Byte) : Byte;
  263. type
  264.   TRequest = record
  265.                Len    : Word;
  266.                SubF   : Byte;
  267.                ObjF   : Boolean;
  268.                ObjSec : Byte;
  269.                ObjT   : Word;
  270.                ObjN   : ObjNameStr;
  271.              end;
  272. var
  273.   Request : ^TRequest;
  274.   Reply   : ^Word;
  275.   NovRegs : Registers;
  276.   S, P : Pointer;
  277. begin
  278.   CreateObject := DPMIErrorVal;
  279.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  280.   Request := P;
  281.   Reply := P;
  282.   Inc(Word(Reply), SizeOf(TRequest));
  283.   Reply^ := $0000;
  284.  
  285.   with Request^ do begin
  286.     Len     := Length(ObjName) + 6;
  287.     SubF    := SubFCreateObj;
  288.     ObjF    := DynamicObj;
  289.     ObjSec  := ObjSecurity;
  290.     ObjT    := Swap(ObjType);
  291.     ObjN    := ObjName;
  292.   end;
  293.  
  294.   with NovRegs do begin
  295.     AH := BinderyFunc;
  296.     DS := SegOfs(S).Segm;
  297.     SI := 0;
  298.     ES := SegOfs(S).Segm;
  299.     DI := SizeOf(TRequest);
  300.     WinIntr($21, NovRegs);
  301.     CreateObject := AL;
  302.   end;
  303.   FreeRealModeMem(P);
  304. end;
  305.  
  306. function CreateProperty(ObjType : Word; ObjName : ObjNameStr;
  307.                         PropertyName : PropertyStr;
  308.                         DynamicProp, SetProp : Boolean;
  309.                         PropertySecurity : Byte) : Byte;
  310. const
  311.   BufSize = SizeOf(ObjNameStr) + (SizeOf(Byte) * 2) + SizeOf(PropertyStr);
  312. type
  313.   TRequest = record
  314.                Len    : Word;
  315.                SubF   : Byte;
  316.                ObjT   : Word;
  317.                Buf    : Array[1..BufSize] of Byte;
  318.              end;
  319. var
  320.   Request : ^TRequest;
  321.   Reply   : ^Word;
  322.   NovRegs : Registers;
  323.   Incr    : Word;
  324.   Index   : Word;
  325.   S, P    : Pointer;
  326. begin
  327.   CreateProperty := DPMIErrorVal;
  328.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  329.   Request := P;
  330.   Reply := P;
  331.   Inc(Word(Reply), SizeOf(TRequest));
  332.   Reply^ := $0000;
  333.  
  334.   with Request^ do begin
  335.     SubF   := SubFCreateProp;
  336.     ObjT   := Swap(ObjType);
  337.     Index  := 1;
  338.     Incr   := Succ(Length(ObjName));
  339.     Move(ObjName,Buf[Index],Incr);
  340.     Inc(Index,Incr);
  341.     Buf[Index] := (Ord(SetProp) shl 1) + Ord(DynamicProp);
  342.     Inc(Index);
  343.     Buf[Index] := PropertySecurity;
  344.     Inc(Index);
  345.     Incr   := Succ(Length(PropertyName));
  346.     Move(PropertyName,Buf[Index],Incr);
  347.     Inc(Index,Incr);
  348.     Len := Index + 2; {3?}
  349.   end;
  350.  
  351.   with NovRegs do begin
  352.     AH := BinderyFunc;
  353.     DS := SegOfs(S).Segm;
  354.     SI := 0;
  355.     ES := SegOfs(S).Segm;
  356.     DI := SizeOf(TRequest);
  357.     WinIntr($21, NovRegs);
  358.     CreateProperty := AL;
  359.   end;
  360.   FreeRealModeMem(P);
  361. end;
  362.  
  363. function DeleteObject(ObjType : Word; ObjName : ObjNameStr) : Byte;
  364. type
  365.   TRequest = record
  366.                Len    : Word;
  367.                SubF   : Byte;
  368.                ObjT   : Word;
  369.                ObjN   : ObjNameStr;
  370.              end;
  371. var
  372.   Request : ^TRequest;
  373.   Reply   : ^Word;
  374.   NovRegs : Registers;
  375.   S, P : Pointer;
  376.  
  377. begin
  378.   DeleteObject := DPMIErrorVal;
  379.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  380.   Request := P;
  381.   Reply := P;
  382.   Inc(Word(Reply), SizeOf(TRequest));
  383.   Reply^ := $0000;
  384.  
  385.   with Request^ do begin
  386.     Len     := Length(ObjName) + 4;
  387.     SubF    := SubFDeleteObj;
  388.     ObjT    := Swap(ObjType);
  389.     ObjN    := ObjName;
  390.   end;
  391.  
  392.   with NovRegs do begin
  393.     AH := BinderyFunc;
  394.     DS := SegOfs(S).Segm;
  395.     SI := 0;
  396.     ES := SegOfs(S).Segm;
  397.     DI := SizeOf(TRequest);
  398.     WinIntr($21, NovRegs);
  399.     DeleteObject := AL;
  400.   end;
  401.   FreeRealModeMem(P);
  402. end;
  403.  
  404. function DeleteObjectFromSet(ObjType : Word; ObjName : ObjNameStr;
  405.                              PropertyName : PropertyStr;
  406.                              MemberObjType : Word;
  407.                              MemberName : ObjNameStr) : Byte;
  408.  
  409. const
  410.   BufSize = (SizeOf(ObjNameStr) * 2) + SizeOf(Word) + SizeOf(PropertyStr);
  411. type
  412.   TRequest = record
  413.                Len    : Word;
  414.                SubF   : Byte;
  415.                ObjT   : Word;
  416.                Buf    : Array[1..BufSize] of Byte;
  417.              end;
  418. var
  419.   Request : ^TRequest;
  420.   Reply   : ^Word;
  421.   NovRegs : Registers;
  422.   Incr    : Word;
  423.   Index   : Word;
  424.   S, P : Pointer;
  425. begin
  426.   DeleteObjectFromSet := DPMIErrorVal;
  427.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  428.   Request := P;
  429.   Reply := P;
  430.   Inc(Word(Reply), SizeOf(TRequest));
  431.   Reply^ := $0000;
  432.  
  433.   with Request^ do begin
  434.     SubF   := SubFDeleteObjFromSet;
  435.     ObjT   := Swap(ObjType);
  436.     Index  := 1;
  437.     Incr   := Succ(Length(ObjName));
  438.     Move(ObjName,Buf[Index],Incr);
  439.     Inc(Index,Incr);
  440.     Incr   := Succ(Length(PropertyName));
  441.     Move(PropertyName,Buf[Index],Incr);
  442.     Inc(Index,Incr);
  443.     MemberObjType := Swap(MemberObjType);
  444.     Move(MemberObjType,Buf[Index],SizeOf(Word));
  445.     Inc(Index,SizeOf(Word));
  446.     Incr   := Succ(Length(MemberName));
  447.     Move(MemberName,Buf[Index],Incr);
  448.     Inc(Index,Incr);
  449.  
  450.     Len := Index + 2; {3?}
  451.   end;
  452.  
  453.   with NovRegs do begin
  454.     AH := BinderyFunc;
  455.     DS := SegOfs(S).Segm;
  456.     SI := 0;
  457.     ES := SegOfs(S).Segm;
  458.     DI := SizeOf(TRequest);
  459.     WinIntr($21, NovRegs);
  460.     DeleteObjectFromSet := AL;
  461.   end;
  462.   FreeRealModeMem(P);
  463. end;
  464.  
  465. function DeleteProperty(ObjType : Word; ObjName : ObjNameStr;
  466.                         PropertyName : PropertyStr) : Byte;
  467.  
  468. const
  469.   BufSize = SizeOf(ObjNameStr) + SizeOf(PropertyStr);
  470.  
  471. type
  472.   TRequest = record
  473.                Len    : Word;
  474.                SubF   : Byte;
  475.                ObjT   : Word;
  476.                Buf    : Array[1..BufSize] of Byte;
  477.              end;
  478. var
  479.   Request : ^TRequest;
  480.   Reply   : ^Word;
  481.   NovRegs : Registers;
  482.   Incr    : Word;
  483.   Index   : Word;
  484.   S, P : Pointer;
  485. begin
  486.   DeleteProperty := DPMIErrorVal;
  487.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  488.   Request := P;
  489.   Reply := P;
  490.   Inc(Word(Reply), SizeOf(TRequest));
  491.   Reply^ := $0000;
  492.  
  493.   with Request^ do begin
  494.     SubF   := SubFDeleteProp;
  495.     ObjT   := Swap(ObjType);
  496.     Index  := 1;
  497.     Incr   := Succ(Length(ObjName));
  498.     Move(ObjName,Buf[Index],Incr);
  499.     Inc(Index,Incr);
  500.     Incr   := Succ(Length(PropertyName));
  501.     Move(PropertyName,Buf[Index],Incr);
  502.     Inc(Index,Incr);
  503.  
  504.     Len := Index + 2; {3?}
  505.   end;
  506.  
  507.   with NovRegs do begin
  508.     AH := BinderyFunc;
  509.     DS := SegOfs(S).Segm;
  510.     SI := 0;
  511.     ES := SegOfs(S).Segm;
  512.     DI := SizeOf(TRequest);
  513.     WinIntr($21, NovRegs);
  514.     DeleteProperty := AL;
  515.   end;
  516. end;
  517.  
  518. function GetBinderyAccessLevel(var AccessLevel : Byte;
  519.                                var ObjectID : LongInt) : Byte;
  520.  
  521. type
  522.   TRequest   = record
  523.                  Len    : Word;
  524.                  SubF   : Byte;
  525.                end;
  526.   TReply     = record
  527.                  Len    : Word;
  528.                  Level  : Byte;
  529.                  ID     : LongInt;
  530.                end;
  531. var
  532.   Request : ^TRequest;
  533.   Reply : ^TReply;
  534.   NovRegs   : Registers;
  535.   S, P : Pointer;
  536. begin
  537.   GetBinderyAccessLevel := DPMIErrorVal;
  538.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  539.   Request := P;
  540.   Reply := P;
  541.   Inc(Word(Reply), SizeOf(TRequest));
  542.   with Request^ do begin
  543.     Len    := 1;
  544.     SubF   := SubFGetAccessLevel;
  545.   end;
  546.  
  547.   Reply^.Len := SizeOf(TReply) - 2;
  548.   with NovRegs do begin
  549.     AH := BinderyFunc;
  550.     DS := SegOfs(S).Segm;
  551.     SI := 0;
  552.     ES := SegOfs(S).Segm;
  553.     DI := SizeOf(TRequest);
  554.     WinIntr($21, NovRegs);
  555.     GetBinderyAccessLevel := AL;
  556.   end;
  557.   with Reply^ do begin
  558.     AccessLevel := Level;
  559.     ObjectID    := NetWareSwapLong(ID);
  560.   end;
  561.   FreeRealModeMem(P);
  562. end;
  563.  
  564. function GetObjectID(var ObjType : Word; var ObjName : ObjNameStr;
  565.                      var ObjID : LongInt) : Byte;
  566. type
  567.   TRequest   = record
  568.                  Len    : Word;
  569.                  SubF   : Byte;
  570.                  ObjT   : Word;
  571.                  ObjN   : ObjNameStr;
  572.                end;
  573.   TReply     = record
  574.                  Len    : Word;
  575.                  ID     : LongInt;
  576.                  ObjT   : Word;
  577.                  ObjN   : ObjNameStr;
  578.                end;
  579. var
  580.   Request : ^TRequest;
  581.   Reply : ^TReply;
  582.   NovRegs   : Registers;
  583.   S, P : Pointer;
  584. begin
  585.   GetObjectID := DPMIErrorVal;
  586.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  587.   Request := P;
  588.   Reply := P;
  589.   Inc(Word(Reply), SizeOf(TRequest));
  590.   with Request^ do begin
  591.     Len    := Length(ObjName) + 4;
  592.     SubF   := SubFGetObjID;
  593.     ObjT   := Swap(ObjType);
  594.     ObjN   := ObjName;
  595.   end;
  596.  
  597.   Reply^.Len := SizeOf(TReply) - 2;
  598.   with NovRegs do begin
  599.     AH := BinderyFunc;
  600.     DS := SegOfs(S).Segm;
  601.     SI := 0;
  602.     ES := SegOfs(S).Segm;
  603.     DI := SizeOf(TRequest);
  604.     WinIntr($21, NovRegs);
  605.     GetObjectID := AL;
  606.   end;
  607.   with Reply^ do begin
  608.     ObjID   := NetWareSwapLong(ID);
  609.     ObjType := Swap(ObjT);
  610.     ObjName := AsciiZ2Str(ObjN,SizeOf(ObjNameStr)-1);
  611.   end;
  612.   FreeRealModeMem(P);
  613. end;
  614.  
  615. function GetObjectName(ObjectID : LongInt;
  616.                        var ObjType : Word;
  617.                        var ObjName : ObjNameStr) : Byte;
  618.  
  619. type
  620.   TRequest   = record
  621.                  Len    : Word;
  622.                  SubF   : Byte;
  623.                  ID     : LongInt;
  624.                end;
  625.   TReply     = record
  626.                  Len    : Word;
  627.                  ID     : LongInt;
  628.                  ObjT   : Word;
  629.                  ObjN   : ObjNameStr;
  630.                end;
  631. var
  632.   Request : ^TRequest;
  633.   Reply : ^TReply;
  634.   NovRegs   : Registers;
  635.   S, P : Pointer;
  636. begin
  637.   GetObjectName := DPMIErrorVal;
  638.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  639.   Request := P;
  640.   Reply := P;
  641.   Inc(Word(Reply), SizeOf(TRequest));
  642.   with Request^ do begin
  643.     Len    := SizeOf(TRequest) - 2;
  644.     SubF   := SubFGetObjName;
  645.     ID     := NetWareSwapLong(ObjectID);
  646.   end;
  647.   Reply^.Len := SizeOf(TReply) - 2;
  648.  
  649.   with NovRegs do begin
  650.     AH := BinderyFunc;
  651.     DS := SegOfs(S).Segm;
  652.     SI := 0;
  653.     ES := SegOfs(S).Segm;
  654.     DI := SizeOf(TRequest);
  655.     WinIntr($21, NovRegs);
  656.     GetObjectName := AL;
  657.   end;
  658.   with Reply^ do begin
  659.     ObjType := Swap(ObjT);
  660.     ObjName := AsciiZ2Str(ObjN,SizeOf(ObjNameStr)-1);
  661.   end;
  662.   FreeRealModeMem(P);
  663. end;
  664.  
  665. function IsObjectInSet(ObjType : Word; ObjName : ObjNameStr;
  666.                        PropertyName  : PropertyStr;
  667.                        MemberObjType : Word;
  668.                        MemberName    : ObjNameStr) : Byte;
  669.   {-Returns 0 as function result if member is in set}
  670. const
  671.   BufSize = (SizeOf(ObjNameStr) * 2) + SizeOf(Word) + SizeOf(PropertyStr);
  672.  
  673. type
  674.   TRequest = record
  675.                Len    : Word;
  676.                SubF   : Byte;
  677.                ObjT   : Word;
  678.                Buf    : Array[1..BufSize] of Byte;
  679.              end;
  680. var
  681.   Request : ^TRequest;
  682.   Reply   : ^Word;
  683.   NovRegs : Registers;
  684.   Incr    : Word;
  685.   Index   : Word;
  686.   S, P : Pointer;
  687. begin
  688.   IsObjectInSet := DPMIErrorVal;
  689.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  690.   Request := P;
  691.   Reply := P;
  692.   Inc(Word(Reply), SizeOf(TRequest));
  693.   Reply^ := $0000;
  694.  
  695.   with Request^ do begin
  696.     SubF   := SubFIsObjInSet;
  697.     ObjT   := Swap(ObjType);
  698.     Index  := 1;
  699.     Incr   := Succ(Length(ObjName));
  700.     Move(ObjName,Buf[Index],Incr);
  701.     Inc(Index,Incr);
  702.     Incr   := Succ(Length(PropertyName));
  703.     Move(PropertyName,Buf[Index],Incr);
  704.     Inc(Index,Incr);
  705.     MemberObjType := Swap(MemberObjType);
  706.     Move(MemberObjType,Buf[Index],SizeOf(Word));
  707.     Inc(Index,SizeOf(Word));
  708.     Incr   := Succ(Length(MemberName));
  709.     Move(MemberName,Buf[Index],Incr);
  710.     Inc(Index,Incr);
  711.     Len := Index + 2; {3?}
  712.   end;
  713.  
  714.   with NovRegs do begin
  715.     AH := BinderyFunc;
  716.     DS := SegOfs(S).Segm;
  717.     SI := 0;
  718.     ES := SegOfs(S).Segm;
  719.     DI := SizeOf(TRequest);
  720.     WinIntr($21, NovRegs);
  721.     IsObjectInSet := AL;
  722.   end;
  723.   FreeRealModeMem(P);
  724. end;
  725.  
  726. function OpenBindery : Boolean;
  727.  
  728. type
  729.   TRequest = record
  730.                Len  : Word;
  731.                SubF : Byte;
  732.              end;
  733. var
  734.   Request : ^TRequest;
  735.   Reply   : ^Word;
  736.   NovRegs : Registers;
  737.   S, P : Pointer;
  738. begin
  739.   OpenBindery := False;
  740.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  741.   Request := P;
  742.   Reply := P;
  743.   Inc(Word(Reply), SizeOf(TRequest));
  744.   Reply^ := $0000;
  745.  
  746.   with Request^ do begin
  747.     Len  := 1;
  748.     SubF := SubFOpenBindery;
  749.   end;
  750.  
  751.   with NovRegs do begin
  752.     AH := BinderyFunc;
  753.     DS := SegOfs(S).Segm;
  754.     SI := 0;
  755.     ES := SegOfs(S).Segm;
  756.     DI := SizeOf(TRequest);
  757.     WinIntr($21, NovRegs);
  758.     OpenBindery := AL = 0;
  759.   end;
  760.   FreeRealModeMem(P);
  761. end;
  762.  
  763. function ReadPropertyValue(ObjType : Word; ObjName : ObjNameStr;
  764.                            SegmentNumber : Byte;
  765.                            PropertyName  : PropertyStr;
  766.                            var PropertyValue : PropertyValueType;
  767.                            var PropertyFlags : Byte;
  768.                            var MoreSegments  : Boolean) : Byte;
  769.  
  770. const
  771.   BufSize = SizeOf(ObjNameStr) + SizeOf(Byte) + SizeOf(PropertyStr);
  772.  
  773. type
  774.   TRequest = record
  775.                Len    : Word;
  776.                SubF   : Byte;
  777.                ObjT   : Word;
  778.                Buf    : Array[1..BufSize] of Byte;
  779.              end;
  780.   TReply   = record
  781.                Len    : Word;
  782.                PVal   : PropertyValueType;
  783.                More   : Byte;
  784.                PFlags : Byte;
  785.              end;
  786. var
  787.   Request : ^TRequest;
  788.   Reply   : ^TReply;
  789.   NovRegs : Registers;
  790.   Incr    : Word;
  791.   Index   : Word;
  792.   S, P : Pointer;
  793. begin
  794.   ReadPropertyValue := DPMIErrorVal;
  795.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  796.   Request := P;
  797.   Reply := P;
  798.   Inc(Word(Reply), SizeOf(TRequest));
  799.   with Request^ do begin
  800.     SubF   := SubFReadPropVal;
  801.     ObjT   := Swap(ObjType);
  802.     Index  := 1;
  803.     Incr   := Succ(Length(ObjName));
  804.     Move(ObjName,Buf[Index],Incr);
  805.     Inc(Index,Incr);
  806.     Buf[Index] := SegmentNumber;
  807.     Inc(Index);
  808.     Incr   := Succ(Length(PropertyName));
  809.     Move(PropertyName,Buf[Index],Incr);
  810.     Inc(Index,Incr);
  811.     Len := Index + 2; {3?}
  812.   end;
  813.   Reply^.Len := SizeOf(TReply) - 2;
  814.   with NovRegs do begin
  815.     AH := BinderyFunc;
  816.     DS := SegOfs(S).Segm;
  817.     SI := 0;
  818.     ES := SegOfs(S).Segm;
  819.     DI := SizeOf(TRequest);
  820.     WinIntr($21, NovRegs);
  821.     ReadPropertyValue := AL;
  822.   end;
  823.   with Reply^ do begin
  824.     PropertyValue := PVal;
  825.     MoreSegments  := More <> 0;
  826.     PropertyFlags := PFlags;
  827.   end;
  828.   FreeRealModeMem(P);
  829. end;
  830.  
  831. function RenameObject(ObjType : Word;
  832.                       OldObjName, NewObjName : ObjNameStr) : Byte;
  833.  
  834. const
  835.   BufSize = SizeOf(ObjNameStr) * 2;
  836.  
  837. type
  838.   TRequest = record
  839.                Len    : Word;
  840.                SubF   : Byte;
  841.                ObjT   : Word;
  842.                Buf    : Array[1..BufSize] of Byte;
  843.              end;
  844. var
  845.   Request : ^TRequest;
  846.   Reply   : ^Word;
  847.   NovRegs : Registers;
  848.   Incr    : Word;
  849.   Index   : Word;
  850.   S, P : Pointer;
  851. begin
  852.   RenameObject := DPMIErrorVal;
  853.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  854.   Request := P;
  855.   Reply := P;
  856.   Inc(Word(Reply), SizeOf(TRequest));
  857.   Reply^ := $0000;
  858.  
  859.   with Request^ do begin
  860.     SubF   := SubFRenameObj;
  861.     ObjT   := Swap(ObjType);
  862.     Index  := 1;
  863.     Incr   := Succ(Length(OldObjName));
  864.     Move(OldObjName,Buf[Index],Incr);
  865.     Inc(Index,Incr);
  866.     Incr   := Succ(Length(NewObjName));
  867.     Move(NewObjName,Buf[Index],Incr);
  868.     Inc(Index,Incr);
  869.     Len := Index + 2; {3?}
  870.   end;
  871.  
  872.   with NovRegs do begin
  873.     AH := BinderyFunc;
  874.     DS := SegOfs(S).Segm;
  875.     SI := 0;
  876.     ES := SegOfs(S).Segm;
  877.     DI := SizeOf(TRequest);
  878.     WinIntr($21, NovRegs);
  879.     RenameObject := AL;
  880.   end;
  881.   FreeRealModeMem(P);
  882. end;
  883.  
  884. function ScanObject(var ObjType       : Word;
  885.                     var ObjName       : ObjNameStr;
  886.                     var ObjID         : LongInt;
  887.                     var ObjFlag       : Byte;
  888.                     var ObjSecurity   : Byte;
  889.                     var HasProperties : Boolean) : Byte;
  890. const
  891.   ReplyBSize = SizeOf(ObjNameStr) + (SizeOf(Byte) * 3);
  892.  
  893. type
  894.   TRequest = record
  895.                Len    : Word;
  896.                SubF   : Byte;
  897.                LastID : LongInt;
  898.                ObjT   : Word;
  899.                ObjN   : ObjNameStr;
  900.              end;
  901.   TReply   = record
  902.                Len    : Word;
  903.                ID     : LongInt;
  904.                ObjT   : Word;
  905.                ObjN   : ObjNameField;
  906.                ObjF   : Byte;
  907.                ObjSec : Byte;
  908.                HasProp: Byte;
  909.              end;
  910. var
  911.   Request : ^TRequest;
  912.   Reply   : ^TReply;
  913.   NovRegs : Registers;
  914.   Index   : Word;
  915.   L       : Word;
  916.   S, P : Pointer;
  917. begin
  918.   ScanObject := DPMIErrorVal;
  919.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  920.   Request := P;
  921.   Reply := P;
  922.   Inc(Word(Reply), SizeOf(TRequest));
  923.   with Request^ do begin
  924.     SubF   := SubFScanObj;
  925.     LastID := NetWareSwapLong(ObjID);
  926.     ObjT   := Swap(ObjType);
  927.     ObjN   := ObjName;
  928.     Len    := Length(ObjName) + 8;
  929.   end;
  930.   Reply^.Len := SizeOf(TReply) - 2;
  931.   with NovRegs do begin
  932.     AH := BinderyFunc;
  933.     DS := SegOfs(S).Segm;
  934.     SI := 0;
  935.     ES := SegOfs(S).Segm;
  936.     DI := SizeOf(TRequest);
  937.     WinIntr($21, NovRegs);
  938.     ScanObject := AL;
  939.     if AL = 0 then
  940.       with Reply^ do begin
  941.         ObjID         := NetWareSwapLong(ID);
  942.         ObjType       := Swap(ObjT);
  943.         ObjName       := AsciiZ2Str(ObjN,SizeOf(ObjNameStr)-1);
  944.         ObjFlag       := ObjF;
  945.         ObjSecurity   := ObjSec;
  946.         HasProperties := HasProp <> 0;
  947.       end;
  948.   end;
  949.   FreeRealModeMem(P);
  950. end;
  951.  
  952. function ScanProperty(ObjType : Word; ObjName : ObjNameStr;
  953.                       var Sequence : LongInt;
  954.                       var PropertyName : PropertyStr;
  955.                       var PropertyFlags, PropertySecurity : Byte;
  956.                       var HasValue, MoreProperties : Boolean) : Byte;
  957.  
  958. const
  959.   BufSize = SizeOf(ObjNameStr) + SizeOf(LongInt) + SizeOf(PropertyStr);
  960. type
  961.   TRequest = record
  962.                Len    : Word;
  963.                SubF   : Byte;
  964.                ObjT   : Word;
  965.                Buf    : Array[1..BufSize] of Byte;
  966.              end;
  967.   TReply   = record
  968.                Len      : Word;
  969.                PropN    : PropertyField;
  970.                PropF    : Byte;
  971.                PropSec  : Byte;
  972.                SeqNum   : LongInt;
  973.                HasVal   : Byte;
  974.                More     : Byte;
  975.              end;
  976. var
  977.   Request : ^TRequest;
  978.   Reply   : ^TReply;
  979.   NovRegs : Registers;
  980.   Index   : Word;
  981.   Incr    : Word;
  982.   S, P : Pointer;
  983. begin
  984.   ScanProperty := DPMIErrorVal;
  985.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(TReply), S, P) then exit;
  986.   Request := P;
  987.   Reply := P;
  988.   Inc(Word(Reply), SizeOf(TRequest));
  989.   with Request^ do begin
  990.     SubF   := SubFScanProp;
  991.     ObjT   := Swap(ObjType);
  992.     Index  := 1;
  993.     Incr   := Succ(Length(ObjName));
  994.     Move(ObjName,Buf[Index],Incr);
  995.     Inc(Index,Incr);
  996.     Move(Sequence,Buf[Index],SizeOf(LongInt));
  997.     Inc(Index,SizeOf(LongInt));
  998.     Incr   := Succ(Length(PropertyName));
  999.     Move(PropertyName,Buf[Index],Incr);
  1000.     Inc(Index,Incr);
  1001.     Len := Index + 2; {3?}
  1002.   end;
  1003.   Reply^.Len := SizeOf(TReply) - 2;
  1004.   with NovRegs do begin
  1005.     AH := BinderyFunc;
  1006.     DS := SegOfs(S).Segm;
  1007.     SI := 0;
  1008.     ES := SegOfs(S).Segm;
  1009.     DI := SizeOf(TRequest);
  1010.     WinIntr($21, NovRegs);
  1011.     ScanProperty := AL;
  1012.     if AL = 0 then
  1013.       with Reply^ do begin
  1014.         PropertyName     := AsciiZ2Str(PropN,SizeOf(PropertyStr) - 1);
  1015.         PropertyFlags    := PropF;
  1016.         PropertySecurity := PropSec;
  1017.         Sequence         := SeqNum;
  1018.         HasValue         := HasVal <> 0;
  1019.         MoreProperties   := More <> 0;
  1020.       end
  1021.     else begin
  1022.       HasValue         := False;
  1023.       MoreProperties   := False;
  1024.     end;
  1025.   end;
  1026.   FreeRealModeMem(P);
  1027. end;
  1028.  
  1029. function VerifyPassword(ObjType : Word; ObjName : ObjNameStr;
  1030.                         Password : PasswordStr) : Byte;
  1031.  
  1032. const
  1033.   BufSize = SizeOf(PasswordStr) + SizeOf(ObjNameStr);
  1034. type
  1035.   TRequest = record
  1036.                Len     : Word;
  1037.                SubF    : Byte;
  1038.                ObjT    : Word;
  1039.                Buf     : Array[1..BufSize] of Char;
  1040.              end;
  1041. var
  1042.   Request : ^TRequest;
  1043.   Reply   : ^Word;
  1044.   NovRegs : Registers;
  1045.   Incr    : Word;
  1046.   Index   : Word;
  1047.   S, P : Pointer;
  1048. begin
  1049.   VerifyPassword := DPMIErrorVal;
  1050.   if not GetRealModeMem(SizeOf(TRequest)+SizeOf(Word), S, P) then exit;
  1051.   Request := P;
  1052.   Reply := P;
  1053.   Inc(Word(Reply), SizeOf(TRequest));
  1054.   Reply^ := $0000;
  1055.  
  1056.   with Request^ do begin
  1057.     SubF   := SubFVerifyPass;
  1058.     ObjT   := Swap(ObjType);
  1059.     Index  := 1;
  1060.     Incr   := Succ(Length(ObjName));
  1061.     Move(ObjName,Buf[Index],Incr);
  1062.     Inc(Index,Incr);
  1063.  
  1064.     Incr   := Succ(Length(Password));
  1065.     Move(Password,Buf[Index],Incr);
  1066.     Inc(Index,Incr);
  1067.     Len := Index + 2;
  1068.   end;
  1069.  
  1070.   with NovRegs do begin
  1071.     AH := BinderyFunc;
  1072.     DS := SegOfs(S).Segm;
  1073.     SI := 0;
  1074.     ES := SegOfs(S).Segm;
  1075.     DI := SizeOf(TRequest);
  1076.     WinIntr($21, NovRegs);
  1077.     VerifyPassword := AL;
  1078.   end;
  1079.   FreeRealModeMem(P);
  1080. end;
  1081.  
  1082.